using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Text;

namespace ns20
{
	internal static class Class195
	{
		[CompilerGenerated]
		private sealed class Class196
		{
			public BindingFlags bindingFlags_0;

			public bool method_0(MemberInfo memberInfo_0)
			{
				if (smethod_28(memberInfo_0, bindingFlags_0))
				{
					return memberInfo_0.Name == "Item";
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class Class197
		{
			public PropertyInfo propertyInfo_0;

			public bool method_0(PropertyInfo propertyInfo_1)
			{
				return propertyInfo_1.Name == propertyInfo_0.Name;
			}

			public bool method_1(PropertyInfo propertyInfo_1)
			{
				if (propertyInfo_1.Name == propertyInfo_0.Name)
				{
					return propertyInfo_1.DeclaringType == propertyInfo_0.DeclaringType;
				}
				return false;
			}

			public bool method_2(PropertyInfo propertyInfo_1)
			{
				if (propertyInfo_1.Name == propertyInfo_0.Name && propertyInfo_1.smethod_0() && propertyInfo_1.smethod_1() != null)
				{
					return propertyInfo_1.smethod_1().DeclaringType.IsAssignableFrom(propertyInfo_0.DeclaringType);
				}
				return false;
			}
		}

		[CompilerGenerated]
		private sealed class Class198
		{
			public Type type_0;

			public string string_0;

			public bool method_0(MethodInfo methodInfo_0)
			{
				if (methodInfo_0.Name == string_0 && methodInfo_0.DeclaringType != type_0)
				{
					return methodInfo_0.GetBaseDefinition().DeclaringType == type_0;
				}
				return false;
			}
		}

		public static readonly Type[] type_0;

		[CompilerGenerated]
		private static Func<ConstructorInfo, bool> func_0;

		[CompilerGenerated]
		private static Func<MemberInfo, string> func_1;

		[CompilerGenerated]
		private static Func<ParameterInfo, Type> func_2;

		[CompilerGenerated]
		private static Func<FieldInfo, bool> func_3;

		static Class195()
		{
			type_0 = Type.EmptyTypes;
		}

		public static bool smethod_0(this PropertyInfo propertyInfo_0)
		{
			Class204.smethod_2(propertyInfo_0, "propertyInfo");
			MethodInfo getMethod = propertyInfo_0.GetGetMethod();
			if (getMethod != null && getMethod.IsVirtual)
			{
				return true;
			}
			getMethod = propertyInfo_0.GetSetMethod();
			if (getMethod != null && getMethod.IsVirtual)
			{
				return true;
			}
			return false;
		}

		public static MethodInfo smethod_1(this PropertyInfo propertyInfo_0)
		{
			Class204.smethod_2(propertyInfo_0, "propertyInfo");
			MethodInfo getMethod = propertyInfo_0.GetGetMethod();
			if (getMethod != null)
			{
				return getMethod.GetBaseDefinition();
			}
			getMethod = propertyInfo_0.GetSetMethod();
			if (getMethod != null)
			{
				return getMethod.GetBaseDefinition();
			}
			return null;
		}

		public static bool smethod_2(PropertyInfo propertyInfo_0)
		{
			if (propertyInfo_0.GetGetMethod() != null && propertyInfo_0.GetGetMethod().IsPublic)
			{
				return true;
			}
			if (propertyInfo_0.GetSetMethod() != null && propertyInfo_0.GetSetMethod().IsPublic)
			{
				return true;
			}
			return false;
		}

		public static Type smethod_3(object object_0)
		{
			return object_0?.GetType();
		}

		public static string smethod_4(Type type_1, FormatterAssemblyStyle formatterAssemblyStyle_0, SerializationBinder serializationBinder_0)
		{
			string text;
			if (serializationBinder_0 != null)
			{
				serializationBinder_0.BindToName(type_1, out var assemblyName, out var typeName);
				text = typeName + ((assemblyName == null) ? "" : (", " + assemblyName));
			}
			else
			{
				text = type_1.AssemblyQualifiedName;
			}
			return formatterAssemblyStyle_0 switch
			{
				FormatterAssemblyStyle.Simple => smethod_5(text), 
				FormatterAssemblyStyle.Full => text, 
				_ => throw new ArgumentOutOfRangeException(), 
			};
		}

		private static string smethod_5(string string_0)
		{
			StringBuilder stringBuilder = new StringBuilder();
			bool flag = false;
			bool flag2 = false;
			foreach (char c in string_0)
			{
				switch (c)
				{
				case '[':
					flag = false;
					flag2 = false;
					stringBuilder.Append(c);
					break;
				default:
					if (!flag2)
					{
						stringBuilder.Append(c);
					}
					break;
				case ']':
					flag = false;
					flag2 = false;
					stringBuilder.Append(c);
					break;
				case ',':
					if (!flag)
					{
						flag = true;
						stringBuilder.Append(c);
					}
					else
					{
						flag2 = true;
					}
					break;
				}
			}
			return stringBuilder.ToString();
		}

		public static bool smethod_6(Type type_1, bool bool_0)
		{
			Class204.smethod_2(type_1, "t");
			if (type_1.smethod_12())
			{
				return true;
			}
			return smethod_8(type_1, bool_0) != null;
		}

		public static ConstructorInfo smethod_7(Type type_1)
		{
			return smethod_8(type_1, bool_0: false);
		}

		public static ConstructorInfo smethod_8(Type type_1, bool bool_0)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (bool_0)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			return type_1.GetConstructors(bindingFlags).SingleOrDefault((ConstructorInfo constructorInfo_0) => !constructorInfo_0.GetParameters().Any());
		}

		public static bool smethod_9(Type type_1)
		{
			Class204.smethod_2(type_1, "t");
			if (type_1.smethod_12())
			{
				return smethod_10(type_1);
			}
			return true;
		}

		public static bool smethod_10(Type type_1)
		{
			Class204.smethod_2(type_1, "t");
			if (type_1.smethod_4())
			{
				return type_1.GetGenericTypeDefinition() == typeof(Nullable<>);
			}
			return false;
		}

		public static Type smethod_11(Type type_1)
		{
			if (!smethod_10(type_1))
			{
				return type_1;
			}
			return Nullable.GetUnderlyingType(type_1);
		}

		public static bool smethod_12(Type type_1, Type type_2)
		{
			if (!type_1.smethod_4())
			{
				return false;
			}
			Type genericTypeDefinition = type_1.GetGenericTypeDefinition();
			return genericTypeDefinition == type_2;
		}

		public static bool smethod_13(Type type_1, Type type_2)
		{
			Type type_3;
			return smethod_14(type_1, type_2, out type_3);
		}

		public static bool smethod_14(Type type_1, Type type_2, out Type type_3)
		{
			Class204.smethod_2(type_1, "type");
			Class204.smethod_2(type_2, "genericInterfaceDefinition");
			if (type_2.smethod_3() && type_2.smethod_5())
			{
				if (type_1.smethod_3() && type_1.smethod_4())
				{
					Type genericTypeDefinition = type_1.GetGenericTypeDefinition();
					if (type_2 == genericTypeDefinition)
					{
						type_3 = type_1;
						return true;
					}
				}
				Type[] interfaces = type_1.GetInterfaces();
				int num = 0;
				Type type;
				while (true)
				{
					if (num < interfaces.Length)
					{
						type = interfaces[num];
						if (type.smethod_4())
						{
							Type genericTypeDefinition2 = type.GetGenericTypeDefinition();
							if (type_2 == genericTypeDefinition2)
							{
								break;
							}
						}
						num++;
						continue;
					}
					type_3 = null;
					return false;
				}
				type_3 = type;
				return true;
			}
			throw new ArgumentNullException("'{0}' is not a generic interface definition.".smethod_0(CultureInfo.InvariantCulture, type_2));
		}

		public static bool smethod_15(Type type_1, Type type_2)
		{
			Type type_3;
			return smethod_16(type_1, type_2, out type_3);
		}

		public static bool smethod_16(Type type_1, Type type_2, out Type type_3)
		{
			Class204.smethod_2(type_1, "type");
			Class204.smethod_2(type_2, "genericClassDefinition");
			if (!type_2.smethod_8() || !type_2.smethod_5())
			{
				throw new ArgumentNullException("'{0}' is not a generic class definition.".smethod_0(CultureInfo.InvariantCulture, type_2));
			}
			return smethod_17(type_1, type_2, out type_3);
		}

		private static bool smethod_17(Type type_1, Type type_2, out Type type_3)
		{
			if (type_1.smethod_4())
			{
				Type genericTypeDefinition = type_1.GetGenericTypeDefinition();
				if (type_2 == genericTypeDefinition)
				{
					type_3 = type_1;
					return true;
				}
			}
			if (type_1.smethod_6() == null)
			{
				type_3 = null;
				return false;
			}
			return smethod_17(type_1.smethod_6(), type_2, out type_3);
		}

		public static Type smethod_18(Type type_1)
		{
			Class204.smethod_2(type_1, "type");
			if (type_1.IsArray)
			{
				return type_1.GetElementType();
			}
			if (smethod_14(type_1, typeof(IEnumerable<>), out var type_2))
			{
				if (type_2.smethod_5())
				{
					throw new Exception("Type {0} is not a collection.".smethod_0(CultureInfo.InvariantCulture, type_1));
				}
				return type_2.GetGenericArguments()[0];
			}
			if (!typeof(IEnumerable).IsAssignableFrom(type_1))
			{
				throw new Exception("Type {0} is not a collection.".smethod_0(CultureInfo.InvariantCulture, type_1));
			}
			return null;
		}

		public static void smethod_19(Type type_1, out Type type_2, out Type type_3)
		{
			Class204.smethod_2(type_1, "type");
			if (smethod_14(type_1, typeof(IDictionary<, >), out var type_4))
			{
				if (type_4.smethod_5())
				{
					throw new Exception("Type {0} is not a dictionary.".smethod_0(CultureInfo.InvariantCulture, type_1));
				}
				Type[] genericArguments = type_4.GetGenericArguments();
				type_2 = genericArguments[0];
				type_3 = genericArguments[1];
			}
			else
			{
				if (!typeof(IDictionary).IsAssignableFrom(type_1))
				{
					throw new Exception("Type {0} is not a dictionary.".smethod_0(CultureInfo.InvariantCulture, type_1));
				}
				type_2 = null;
				type_3 = null;
			}
		}

		public static Type smethod_20(MemberInfo memberInfo_0)
		{
			Class204.smethod_2(memberInfo_0, "member");
			return memberInfo_0.smethod_1() switch
			{
				MemberTypes.Property => ((PropertyInfo)memberInfo_0).PropertyType, 
				MemberTypes.Event => ((EventInfo)memberInfo_0).EventHandlerType, 
				MemberTypes.Field => ((FieldInfo)memberInfo_0).FieldType, 
				_ => throw new ArgumentException("MemberInfo must be of type FieldInfo, PropertyInfo or EventInfo", "member"), 
			};
		}

		public static bool smethod_21(MemberInfo memberInfo_0)
		{
			Class204.smethod_2(memberInfo_0, "member");
			PropertyInfo propertyInfo = memberInfo_0 as PropertyInfo;
			if (propertyInfo != null)
			{
				return smethod_22(propertyInfo);
			}
			return false;
		}

		public static bool smethod_22(PropertyInfo propertyInfo_0)
		{
			Class204.smethod_2(propertyInfo_0, "property");
			return propertyInfo_0.GetIndexParameters().Length > 0;
		}

		public static object smethod_23(MemberInfo memberInfo_0, object object_0)
		{
			Class204.smethod_2(memberInfo_0, "member");
			Class204.smethod_2(object_0, "target");
			switch (memberInfo_0.smethod_1())
			{
			default:
				throw new ArgumentException("MemberInfo '{0}' is not of type FieldInfo or PropertyInfo".smethod_1(CultureInfo.InvariantCulture, CultureInfo.InvariantCulture, memberInfo_0.Name), "member");
			case MemberTypes.Property:
				try
				{
					return ((PropertyInfo)memberInfo_0).GetValue(object_0, null);
				}
				catch (TargetParameterCountException innerException)
				{
					throw new ArgumentException("MemberInfo '{0}' has index parameters".smethod_0(CultureInfo.InvariantCulture, memberInfo_0.Name), innerException);
				}
			case MemberTypes.Field:
				return ((FieldInfo)memberInfo_0).GetValue(object_0);
			}
		}

		public static void smethod_24(MemberInfo memberInfo_0, object object_0, object object_1)
		{
			Class204.smethod_2(memberInfo_0, "member");
			Class204.smethod_2(object_0, "target");
			switch (memberInfo_0.smethod_1())
			{
			default:
				throw new ArgumentException("MemberInfo '{0}' must be of type FieldInfo or PropertyInfo".smethod_0(CultureInfo.InvariantCulture, memberInfo_0.Name), "member");
			case MemberTypes.Property:
				((PropertyInfo)memberInfo_0).SetValue(object_0, object_1, null);
				break;
			case MemberTypes.Field:
				((FieldInfo)memberInfo_0).SetValue(object_0, object_1);
				break;
			}
		}

		public static bool smethod_25(MemberInfo memberInfo_0, bool bool_0)
		{
			switch (memberInfo_0.smethod_1())
			{
			default:
				return false;
			case MemberTypes.Property:
			{
				PropertyInfo propertyInfo = (PropertyInfo)memberInfo_0;
				if (!propertyInfo.CanRead)
				{
					return false;
				}
				if (bool_0)
				{
					return true;
				}
				return propertyInfo.GetGetMethod(bool_0) != null;
			}
			case MemberTypes.Field:
			{
				FieldInfo fieldInfo = (FieldInfo)memberInfo_0;
				if (bool_0)
				{
					return true;
				}
				if (fieldInfo.IsPublic)
				{
					return true;
				}
				return false;
			}
			}
		}

		public static bool smethod_26(MemberInfo memberInfo_0, bool bool_0, bool bool_1)
		{
			switch (memberInfo_0.smethod_1())
			{
			default:
				return false;
			case MemberTypes.Property:
			{
				PropertyInfo propertyInfo = (PropertyInfo)memberInfo_0;
				if (!propertyInfo.CanWrite)
				{
					return false;
				}
				if (bool_0)
				{
					return true;
				}
				return propertyInfo.GetSetMethod(bool_0) != null;
			}
			case MemberTypes.Field:
			{
				FieldInfo fieldInfo = (FieldInfo)memberInfo_0;
				if (fieldInfo.IsInitOnly && !bool_1)
				{
					return false;
				}
				if (bool_0)
				{
					return true;
				}
				if (fieldInfo.IsPublic)
				{
					return true;
				}
				return false;
			}
			}
		}

		public static List<MemberInfo> smethod_27(Type type_1, BindingFlags bindingFlags_0)
		{
			List<MemberInfo> list = new List<MemberInfo>();
			list.AddRange(smethod_35(type_1, bindingFlags_0));
			list.AddRange(smethod_37(type_1, bindingFlags_0));
			List<MemberInfo> list2 = new List<MemberInfo>(list.Count);
			foreach (IGrouping<string, MemberInfo> item in from memberInfo_0 in list
				group memberInfo_0 by memberInfo_0.Name)
			{
				int num = item.Count();
				IList<MemberInfo> source = item.ToList();
				if (num == 1)
				{
					list2.Add(source.First());
					continue;
				}
				IEnumerable<MemberInfo> collection = source.Where((MemberInfo memberInfo_0) => !smethod_28(memberInfo_0, bindingFlags_0) || memberInfo_0.Name == "Item");
				list2.AddRange(collection);
			}
			return list2;
		}

		private static bool smethod_28(MemberInfo memberInfo_0, BindingFlags bindingFlags_0)
		{
			MemberTypes memberTypes = memberInfo_0.smethod_1();
			if (memberTypes != MemberTypes.Field && memberTypes != MemberTypes.Property)
			{
				throw new ArgumentException("Member must be a field or property.");
			}
			Type declaringType = memberInfo_0.DeclaringType;
			if (!declaringType.smethod_4())
			{
				return false;
			}
			Type genericTypeDefinition = declaringType.GetGenericTypeDefinition();
			if (genericTypeDefinition == null)
			{
				return false;
			}
			MemberInfo[] member = genericTypeDefinition.GetMember(memberInfo_0.Name, bindingFlags_0);
			if (member.Length == 0)
			{
				return false;
			}
			Type type = smethod_20(member[0]);
			if (!type.IsGenericParameter)
			{
				return false;
			}
			return true;
		}

		public static T smethod_29<T>(object object_0) where T : Attribute
		{
			return smethod_30<T>(object_0, bool_0: true);
		}

		public static T smethod_30<T>(object object_0, bool bool_0) where T : Attribute
		{
			T[] array = smethod_31<T>(object_0, bool_0);
			if (array == null)
			{
				return null;
			}
			return array.SingleOrDefault();
		}

		public static T[] smethod_31<T>(object object_0, bool bool_0) where T : Attribute
		{
			Class204.smethod_2(object_0, "attributeProvider");
			if (object_0 is Type)
			{
				return (T[])((Type)object_0).GetCustomAttributes(typeof(T), bool_0);
			}
			if (object_0 is Assembly)
			{
				return (T[])Attribute.GetCustomAttributes((Assembly)object_0, typeof(T));
			}
			if (object_0 is MemberInfo)
			{
				return (T[])Attribute.GetCustomAttributes((MemberInfo)object_0, typeof(T), bool_0);
			}
			if (object_0 is Module)
			{
				return (T[])Attribute.GetCustomAttributes((Module)object_0, typeof(T), bool_0);
			}
			if (object_0 is ParameterInfo)
			{
				return (T[])Attribute.GetCustomAttributes((ParameterInfo)object_0, typeof(T), bool_0);
			}
			return (T[])((ICustomAttributeProvider)object_0).GetCustomAttributes(typeof(T), bool_0);
		}

		public static void smethod_32(string string_0, out string string_1, out string string_2)
		{
			int? num = smethod_33(string_0);
			if (num.HasValue)
			{
				string_1 = string_0.Substring(0, num.Value).Trim();
				string_2 = string_0.Substring(num.Value + 1, string_0.Length - num.Value - 1).Trim();
			}
			else
			{
				string_1 = string_0;
				string_2 = null;
			}
		}

		private static int? smethod_33(string string_0)
		{
			int num = 0;
			for (int i = 0; i < string_0.Length; i++)
			{
				switch (string_0[i])
				{
				case '[':
					num++;
					break;
				case ']':
					num--;
					break;
				case ',':
					if (num == 0)
					{
						return i;
					}
					break;
				}
			}
			return null;
		}

		public static MemberInfo smethod_34(Type type_1, MemberInfo memberInfo_0)
		{
			MemberTypes memberTypes = memberInfo_0.smethod_1();
			if (memberTypes == MemberTypes.Property)
			{
				PropertyInfo propertyInfo = (PropertyInfo)memberInfo_0;
				Type[] types = (from parameterInfo_0 in propertyInfo.GetIndexParameters()
					select parameterInfo_0.ParameterType).ToArray();
				return type_1.GetProperty(propertyInfo.Name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, propertyInfo.PropertyType, types, null);
			}
			return type_1.GetMember(memberInfo_0.Name, memberInfo_0.smethod_1(), BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).SingleOrDefault();
		}

		public static IEnumerable<FieldInfo> smethod_35(Type type_1, BindingFlags bindingFlags_0)
		{
			Class204.smethod_2(type_1, "targetType");
			List<MemberInfo> list = new List<MemberInfo>(type_1.GetFields(bindingFlags_0));
			smethod_36(list, type_1, bindingFlags_0);
			return list.Cast<FieldInfo>();
		}

		private static void smethod_36(IList<MemberInfo> ilist_0, Type type_1, BindingFlags bindingFlags_0)
		{
			if ((bindingFlags_0 & BindingFlags.NonPublic) == 0)
			{
				return;
			}
			BindingFlags bindingAttr = bindingFlags_0.smethod_38(BindingFlags.Public);
			while ((type_1 = type_1.smethod_6()) != null)
			{
				IEnumerable<MemberInfo> ienumerable_ = (from fieldInfo_0 in type_1.GetFields(bindingAttr)
					where fieldInfo_0.IsPrivate
					select fieldInfo_0).Cast<MemberInfo>();
				ilist_0.smethod_1(ienumerable_);
			}
		}

		public static IEnumerable<PropertyInfo> smethod_37(Type type_1, BindingFlags bindingFlags_0)
		{
			Class204.smethod_2(type_1, "targetType");
			List<PropertyInfo> list = new List<PropertyInfo>(type_1.GetProperties(bindingFlags_0));
			smethod_39(list, type_1, bindingFlags_0);
			for (int i = 0; i < list.Count; i++)
			{
				PropertyInfo propertyInfo = list[i];
				if (propertyInfo.DeclaringType != type_1)
				{
					PropertyInfo propertyInfo3 = (list[i] = (PropertyInfo)smethod_34(propertyInfo.DeclaringType, propertyInfo));
				}
			}
			return list;
		}

		public static BindingFlags smethod_38(this BindingFlags bindingFlags_0, BindingFlags bindingFlags_1)
		{
			if ((bindingFlags_0 & bindingFlags_1) != bindingFlags_1)
			{
				return bindingFlags_0;
			}
			return bindingFlags_0 ^ bindingFlags_1;
		}

		private static void smethod_39(IList<PropertyInfo> ilist_0, Type type_1, BindingFlags bindingFlags_0)
		{
			while ((type_1 = type_1.smethod_6()) != null)
			{
				PropertyInfo[] properties = type_1.GetProperties(bindingFlags_0);
				foreach (PropertyInfo propertyInfo in properties)
				{
					PropertyInfo propertyInfo_2 = propertyInfo;
					if (!smethod_2(propertyInfo_2))
					{
						int num = ilist_0.smethod_8((PropertyInfo propertyInfo_1) => propertyInfo_1.Name == propertyInfo_2.Name);
						if (num == -1)
						{
							ilist_0.Add(propertyInfo_2);
						}
						else
						{
							ilist_0[num] = propertyInfo_2;
						}
					}
					else if (!propertyInfo_2.smethod_0())
					{
						int num2 = ilist_0.smethod_8((PropertyInfo propertyInfo_1) => propertyInfo_1.Name == propertyInfo_2.Name && propertyInfo_1.DeclaringType == propertyInfo_2.DeclaringType);
						if (num2 == -1)
						{
							ilist_0.Add(propertyInfo_2);
						}
					}
					else
					{
						int num3 = ilist_0.smethod_8((PropertyInfo propertyInfo_1) => propertyInfo_1.Name == propertyInfo_2.Name && propertyInfo_1.smethod_0() && propertyInfo_1.smethod_1() != null && propertyInfo_1.smethod_1().DeclaringType.IsAssignableFrom(propertyInfo_2.DeclaringType));
						if (num3 == -1)
						{
							ilist_0.Add(propertyInfo_2);
						}
					}
				}
			}
		}

		public static bool smethod_40(Type type_1, Type type_2, string string_0)
		{
			return type_1.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).Any((MethodInfo methodInfo_0) => methodInfo_0.Name == string_0 && methodInfo_0.DeclaringType != type_2 && methodInfo_0.GetBaseDefinition().DeclaringType == type_2);
		}

		public static object smethod_41(Type type_1)
		{
			if (!type_1.smethod_12())
			{
				return null;
			}
			switch (Class182.smethod_0(type_1))
			{
			case Enum17.BigInteger:
				return default(BigInteger);
			case Enum17.Boolean:
				return false;
			case Enum17.Char:
			case Enum17.SByte:
			case Enum17.Int16:
			case Enum17.UInt16:
			case Enum17.Int32:
			case Enum17.Byte:
			case Enum17.UInt32:
				return 0;
			case Enum17.Int64:
			case Enum17.UInt64:
				return 0L;
			case Enum17.Single:
				return 0f;
			case Enum17.Double:
				return 0.0;
			case Enum17.DateTime:
				return default(DateTime);
			case Enum17.DateTimeOffset:
				return default(DateTimeOffset);
			case Enum17.Decimal:
				return 0m;
			default:
				if (smethod_9(type_1))
				{
					return null;
				}
				return Activator.CreateInstance(type_1);
			case Enum17.Guid:
				return default(Guid);
			}
		}

		[CompilerGenerated]
		private static bool smethod_42(ConstructorInfo constructorInfo_0)
		{
			return !constructorInfo_0.GetParameters().Any();
		}

		[CompilerGenerated]
		private static string smethod_43(MemberInfo memberInfo_0)
		{
			return memberInfo_0.Name;
		}

		[CompilerGenerated]
		private static Type smethod_44(ParameterInfo parameterInfo_0)
		{
			return parameterInfo_0.ParameterType;
		}

		[CompilerGenerated]
		private static bool smethod_45(FieldInfo fieldInfo_0)
		{
			return fieldInfo_0.IsPrivate;
		}
	}
}
